home *** CD-ROM | disk | FTP | other *** search
/ Aminet 35 / Aminet 35 (2000)(Schatztruhe)[!][Feb 2000].iso / Aminet / dev / src / td01_src.lha / td_r0.1 / source / tdoold.c < prev   
Encoding:
C/C++ Source or Header  |  1999-05-16  |  26.4 KB  |  954 lines
  1. /*
  2. **      $VER: tdo.c 0.1 (17.4.99)
  3. **
  4. **      Creation date     : 11.10.1998
  5. **
  6. **      Description       :
  7. **         tdo library.
  8. **
  9. **
  10. **      Written by Stephan Bielmann
  11. **
  12. */
  13.  
  14. /*************************** Includes *******************************/
  15.  
  16. /*
  17. ** ANSI standart includes
  18. */
  19. #include <string.h>
  20. #include <math.h>
  21.  
  22. /*
  23. ** Amiga includes
  24. */
  25. #include <exec/types.h>
  26. #include <exec/memory.h>
  27. #include <dos/stdio.h>
  28.  
  29. #include <clib/dos_protos.h>
  30. #include <clib/alib_stdio_protos.h>
  31.  
  32. #include <pragma/exec_lib.h>
  33.  
  34. /*
  35. ** Project includes
  36. */
  37. #include "tdo_private.h"
  38. #include "compiler.h"
  39. #include "pragma/s3_lib.h"
  40.  
  41. /********************** Private constants ***************************/
  42.  
  43. /*
  44. ** The constant supported file format arrays
  45. */
  46.  
  47. //dummi hummi
  48. static ULONG c3dFFIDs [] = { 0 };
  49.  
  50. static STRPTR  c3dFFLib [] = {
  51.     "dxf.library",
  52.     NULL
  53. };
  54.  
  55. static STRPTR c3dFFNames [] = {
  56.     "AutoCAD DXF",
  57.     NULL
  58. };
  59.  
  60. static STRPTR c3dFFExtensions [] = {
  61.     "dxf",
  62.     NULL
  63. };
  64.  
  65. static ULONG  c2dFFIDs   [] = {
  66.     T2DFEPS,
  67.     0
  68. };
  69.  
  70. static STRPTR c2dFFNames [] = {
  71.     "Encapsulated PostScript",
  72.     NULL
  73. };
  74.  
  75. static STRPTR c2dFFExtensions [] = {
  76.     "eps",
  77.     NULL
  78. };
  79.  
  80.  
  81. /*
  82. ** The constant supported drawing mode arrays
  83. */
  84. static ULONG  cDMIDs   [] = {
  85.     TDMPOINTS,
  86.     TDMWIREBW,
  87.     TDMWIREGR,
  88.     TDMWIRECL,
  89.     TDMHIDDBW,
  90.     TDMHIDDGR,
  91.     TDMHIDDCL,
  92.     TDMSURFBW,
  93.     TDMSURFGR,
  94.     TDMSURFCL,
  95.     0
  96. };
  97.  
  98. static STRPTR  cDMNames   [] = {
  99.     "Points, black and white",
  100.     "Wireframe, black and white",
  101.     "Wireframe, gray scales",
  102.     "Wireframe, colors",
  103.     "Hidden line, black and white",
  104.     "Hidden line, gray scales",
  105.     "Hidden line, colors",
  106.     "Surface, black and white",
  107.     "Surface, gray scales",
  108.     "Surface, colors",
  109.     NULL
  110. };
  111.  
  112. /*
  113. ** Definition of PI
  114. */
  115. #define PI 3.14159265359
  116.  
  117. /********************** Global variables ****************************/
  118.  
  119. struct s3Base *s3Base = NULL;
  120.  
  121. /********************** Private functions ***************************/
  122.  
  123. /********************************************************************\
  124. *                                                                    *
  125. * Name         : hash                                                *
  126. *                                                                    *
  127. * Description  : Calculates the hashcode of a vertex.                *
  128. *                                                                    *
  129. * Arguments    : vertex IN : The vertex to hash.                     *
  130. *                                                                    *
  131. * Return Value : hashcode                                            *
  132. *                                                                    *
  133. * Comment      :                                                     *
  134. *                                                                    *
  135. \********************************************************************/
  136. static ULONG hash(TTDOVertex vertex) {
  137.     DOUBLE  hx = vertex.x*12.3;
  138.     DOUBLE  hy = vertex.y*23.4;
  139.     DOUBLE  hz = vertex.z*34.5;
  140.  
  141.     return (((ULONG) (pow(hx*hx + hy*hy + hz*hz,0.5) * 9.87)) % HASHSIZE);
  142. }
  143.  
  144. /********************************************************************\
  145. *                                                                    *
  146. * Name         : addVertex                                           *
  147. *                                                                    *
  148. * Description  : Adds the vertex to the mesh, if not already in its  *
  149. *                internal list. And returns the pointer to it.       *
  150. *                The vertex will be transformed according the mehs   *
  151. *                its CTM.
  152. *                                                                    *
  153. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  154. *                vertex IN : The vertex to add.                      *
  155. *                                                                    *
  156. * Return Value : Pointer to the "new" vertex or NULL if no more      *
  157. *                memory is available.                                *
  158. *                                                                    *
  159. * Comment      :                                                     *
  160. *                                                                    *
  161. \********************************************************************/
  162. static TTDOVertexNode *addVertex(TTDOMesh *mesh,
  163.                                  TTDOVertex vertex) {
  164.  
  165.     ULONG    hashcode;
  166.     TTDOHashsVerticesNode    *hlvindex=NULL;
  167.     TTDOVertexNode            *ver=NULL;
  168.     TTDOCTM                ctm;
  169.     TTDOVertex             rvertex;
  170.  
  171.     ctm=mesh->ctm;
  172.  
  173.     /*
  174.     ** Transforming the the vertex according the CTM
  175.     */
  176.     // Scaling
  177.     vertex.x*=ctm.sx,vertex.y*=ctm.sy,vertex.z*=ctm.sz;
  178.  
  179.     //Rotation and translation
  180.     rvertex.x=ctm.m[0][0]*vertex.x+ctm.m[1][0]*vertex.y+ctm.m[2][0]*vertex.z+ctm.m[3][0]; 
  181.     rvertex.y=ctm.m[0][1]*vertex.x+ctm.m[1][1]*vertex.y+ctm.m[2][1]*vertex.z+ctm.m[3][1]; 
  182.     rvertex.z=ctm.m[0][2]*vertex.x+ctm.m[1][2]*vertex.y+ctm.m[2][2]*vertex.z+ctm.m[3][2]; 
  183.  
  184.     // initialize the hashcode
  185.     hashcode=hash(rvertex);
  186.  
  187.     /*
  188.     ** Check if the vertex is already in our internal list
  189.     */
  190.     hlvindex=mesh->hashTable[hashcode];
  191.     while(hlvindex!=NULL)
  192.     {
  193.           ver=hlvindex->vertexNode;
  194.  
  195.         if(rvertex.x==ver->vertex.x &&
  196.            rvertex.y==ver->vertex.y &&
  197.            rvertex.z==ver->vertex.z ) {
  198.             /*
  199.             ** Yes, return its pointer
  200.             */
  201.             return (ver);
  202.         }
  203.         hlvindex=hlvindex->next;
  204.     }
  205.     
  206.     /*
  207.     ** No it was not. Add a new one to the list and hash and return it
  208.     */
  209.     ver = AllocPooled(mesh->vertexpool,sizeof(TTDOVertexNode));
  210.     if (ver==NULL) return(NULL);
  211.     
  212.     /* The index begins at 1 ! */
  213.     mesh->vertices.numberOfVertices++;            /* increment the list counter */
  214.     ver->index=mesh->vertices.numberOfVertices;    /* Set the index */
  215.     ver->vertex = rvertex;
  216.     ver->next=NULL;
  217.  
  218.     if(mesh->vertices.firstNode!=NULL) {   /* Check if this is the first vertex to insert or not */
  219.         mesh->vertices.lastNode->next=ver;
  220.         mesh->vertices.lastNode=ver;
  221.     }
  222.     else {
  223.         mesh->vertices.lastNode=ver;
  224.         mesh->vertices.firstNode=ver;
  225.     }
  226.  
  227.     /*
  228.     ** Recalculate the bounding box
  229.     */
  230.     if(rvertex.x<mesh->bBox.left)   mesh->bBox.left=rvertex.x;
  231.     if(rvertex.x>mesh->bBox.right)  mesh->bBox.right=rvertex.x;
  232.     if(rvertex.y<mesh->bBox.rear)   mesh->bBox.rear=rvertex.y;
  233.     if(rvertex.y>mesh->bBox.front)  mesh->bBox.front=rvertex.y;
  234.     if(rvertex.z<mesh->bBox.bottom) mesh->bBox.bottom=rvertex.z;
  235.     if(rvertex.z>mesh->bBox.top)    mesh->bBox.top=rvertex.z;
  236.     
  237.     /*
  238.     ** Add the vertex to the hash table
  239.     */
  240.     hlvindex = AllocMem(sizeof(TTDOHashsVerticesNode),MEMF_FAST);
  241.     if (hlvindex==NULL) {
  242.         FreePooled(mesh->vertexpool,ver,sizeof(TTDOVertexNode));
  243.         return(NULL);
  244.     }
  245.     
  246.     hlvindex->vertexNode=ver;
  247.     hlvindex->next=mesh->hashTable[hashcode];
  248.     mesh->hashTable[hashcode]=hlvindex;
  249.     
  250.     return(ver);
  251. }
  252.  
  253. /********************************************************************\
  254. *                                                                    *
  255. * Name         : getVertex                                           *
  256. *                                                                    *
  257. * Description  : Search a vertex in the list with its index.         *
  258. *                                                                    *
  259. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  260. *                index  IN : The vertex its index.                   *
  261. *                                                                    *
  262. * Return Value : Pointer to the vertex or NULL if not found.         *
  263. *                                                                    *
  264. * Comment      :                                                     *
  265. *                                                                    *
  266. \********************************************************************/
  267. static TTDOVertexNode *getVertex(TTDOMesh *mesh,
  268.                                 ULONG index) {
  269.  
  270.     TTDOVertexNode            *ver=NULL;
  271.  
  272.     if(index==0) return(NULL);
  273.  
  274.     ver=mesh->vertices.firstNode;
  275.     while(ver!=NULL && ver->index!=index) {
  276.         ver=ver->next;
  277.     }
  278.  
  279.     return(ver);
  280. }
  281.  
  282. /********************************************************************\
  283. *                                                                    *
  284. * Name         : getVertexIndex                                      *
  285. *                                                                    *
  286. * Description  : Search the index of a vertex in the list with its   *
  287. *                coordinates.                                        *
  288. *                                                                    *
  289. * Arguments    : mesh   IN : Pointer to the mesh.                    *
  290. *                vertex IN : The vertex to search for.               *
  291. *                                                                    *
  292. * Return Value : Index to the vertex or 0 if not found.              *
  293. *                                                                    *
  294. * Comment      :                                                     *
  295. *                                                                    *
  296. \********************************************************************/
  297. static ULONG getVertexIndex(TTDOMesh *mesh,
  298.                             TTDOVertex vertex) {
  299.  
  300.     ULONG    hashcode        =hash(vertex);
  301.     TTDOHashsVerticesNode    *hlvindex=NULL;
  302.     TTDOVertexNode            *ver=NULL;
  303.  
  304.     /*
  305.     ** Check if the vertex is already in our internal list
  306.     */
  307.     hlvindex=mesh->hashTable[hashcode];
  308.     while(hlvindex!=NULL)
  309.     {
  310.           ver=hlvindex->vertexNode;
  311.  
  312.         if(vertex.x==ver->vertex.x &&
  313.            vertex.y==ver->vertex.y &&
  314.            vertex.z==ver->vertex.z ) {
  315.             /*
  316.             ** Yes, return its index
  317.             */
  318.             return (ver->index);
  319.         }
  320.         hlvindex=hlvindex->next;
  321.     }
  322.     
  323.     /*
  324.     ** No it was not.
  325.     */
  326.     return(0);
  327. }
  328.  
  329. /********************************************************************\
  330. *                                                                    *
  331. * Name         : getMaterialNode                                     *
  332. *                                                                    *
  333. * Description  : Search the material its node with its index, in     *
  334. *                the given mesh. If the index=0 or not valid, NULL   *
  335. *                will be returned.                                   *
  336. *                                                                    *
  337. * Arguments    : mesh          IN : Pointer to the mesh.             *
  338. *                materialindex IN : Material index.                  *
  339. *                                                                    *
  340. * Return Value : Pointer to the material or NULL if not found.       *
  341. *                                                                    *
  342. * Comment      :                                                     *
  343. *                                                                    *
  344. \********************************************************************/
  345. static TTDOMaterialNode *getMaterialNode(TTDOMesh *mesh, ULONG materialindex) {
  346.     TTDOMaterialNode    *mindex=NULL;
  347.     
  348.     if(materialindex==0 || materialindex>mesh->materials.numberOfMaterials) return(NULL);
  349.     
  350.     /*
  351.     ** Search the material
  352.     */
  353.     mindex=mesh->materials.firstNode;
  354.     while(mindex!=NULL) {
  355.         if(mindex->index==materialindex) return(mindex);
  356.         
  357.         mindex=mindex->next;
  358.     }
  359.  
  360.     /*
  361.     ** Not found
  362.     */    
  363.     return(NULL);
  364. }
  365.  
  366. /********************************************************************\
  367. *                                                                    *
  368. * Name         : setCameraLight                                      *
  369. *                                                                    *
  370. * Description  : Sets the default position of the camera and the     *
  371. *                light and the camera its view point and the color   *
  372. *                of the light source.                                *
  373. *                                                                    *
  374. * Arguments    : mesh      IN/OUT : Pointer to the mesh.             *
  375. *                                                                    *
  376. * Comment      :                                                     *
  377. *                                                                    *
  378. \********************************************************************/
  379. static VOID setCameraLight(TTDOMesh *mesh) {
  380.     TTDOVertex ver1;
  381.         
  382.     if (mesh==NULL) return;
  383.  
  384.     /* camera its look at position */
  385.     mesh->camera.lookat.x = (mesh->bBox.left + mesh->bBox.right) / 2;
  386.     mesh->camera.lookat.y = (mesh->bBox.front + mesh->bBox.rear) / 2;
  387.     mesh->camera.lookat.z = (mesh->bBox.top + mesh->bBox.bottom) / 2;
  388.     
  389.     /* direction vector */
  390.     ver1.x = mesh->bBox.right - mesh->camera.lookat.x;
  391.     ver1.y = mesh->bBox.front - mesh->camera.lookat.y;
  392.     ver1.z = mesh->bBox.top - mesh->camera.lookat.z;
  393.     
  394.     ver1.x*=2.5;
  395.     ver1.y*=2.5;    
  396.     ver1.z*=2.5;
  397.     
  398.     /* camera its position */
  399.     mesh->camera.position.x = ver1.x + mesh->camera.lookat.x;
  400.     mesh->camera.position.y = ver1.y + mesh->camera.lookat.y;
  401.     mesh->camera.position.z = ver1.z + mesh->camera.lookat.z;
  402.  
  403.     /* light source its position */
  404.     mesh->light.position.x = ver1.x + mesh->camera.lookat.x;
  405.     mesh->light.position.y = ver1.x + mesh->camera.lookat.x;
  406.     mesh->light.position.z = ver1.x + mesh->camera.lookat.x;
  407.     
  408.     /* light source its color */
  409.     mesh->light.color.r=255;
  410.     mesh->light.color.g=255;
  411.     mesh->light.color.b=255;
  412. }
  413.  
  414. /********************************************************************\
  415. *                                                                    *
  416. * Name         : mul33Matrix                                         *
  417. *                                                                    *
  418. * Description  : Multiplicates two 3x3 matrix structures.            *
  419. *                                                                    *
  420. * Arguments    : m1  IN/OUT : The first matrix, contains the result  *
  421. *                m2  IN     : The second matrix.                     *
  422. *                                                                    *
  423. * Comment      :                                                     *
  424. *                                                                    *
  425. \********************************************************************/
  426. void mulMatrix (double m1[3][3], double m2[3][3]) {
  427.     double m[3][3];
  428.     int x,y,yy;
  429.  
  430.     for(x=0;x<3;x++) {
  431.         for(y=0;y<3;y++) {
  432.             m[x][y]=0;
  433.         }
  434.     }
  435.  
  436.     for(x=0;x<3;x++) {
  437.         for(y=0;y<3;y++) {
  438.             for(yy=0;yy<3;yy++) {
  439.                 m[x][y]+=m1[yy][y]*m2[x][yy];
  440.             }
  441.         }
  442.     }
  443.  
  444.     m1[0][0]=m[0][0];
  445.     m1[1][0]=m[1][0];
  446.     m1[2][0]=m[2][0];
  447.     m1[0][1]=m[0][1];
  448.     m1[1][1]=m[1][1];
  449.     m1[2][1]=m[2][1];
  450.     m1[0][2]=m[0][2];
  451.     m1[1][2]=m[1][2];
  452.     m1[2][2]=m[2][2];
  453. }
  454.  
  455. /********************** Public functions ****************************/
  456.  
  457. /****** tdo.library/tdo2DFileFormatNamesGet ******************************************
  458. * 
  459. *   NAME    
  460. *     tdo2DFileFormatNamesGet -- Get a name list of all supported 2D file formats.
  461. * 
  462. *   SYNOPSIS
  463. *    list = tdo2DFileFormatNamesGet(  )
  464. *
  465. *    STRPTR * tdo2DFileFormatNamesGet
  466. *         (  );
  467. *
  468. *   FUNCTION
  469. *    You will get a pointer to the namelist of all supported 2D file formats.
  470. *    This strings are READ_ONLY and only valid as long as the library is opened.
  471. *
  472. *    The list is sorted alphabetically.
  473. *
  474. *    The resulting pointer can directly be used to fill up cycle or list gadgets
  475. *    for example.
  476. * 
  477. *   INPUTS
  478. *    
  479. *   RESULT
  480. *     list - A NULL terminated array of string pointers. Or NULL if no
  481. *           files are supported.
  482. *
  483. *   EXAMPLE
  484. *    list = tdo2DFileFormatNamesGet();
  485. *
  486. *   NOTES
  487. *
  488. *   BUGS
  489. * 
  490. *   SEE ALSO
  491. *     tdo2DFileFormatIDGet(),tdo2DFileFormatExtensionGet()
  492. *    tdo2DFileFormatNumberOfGet()
  493. * 
  494. ******************************************************************************
  495. *
  496. */
  497. STRPTR * __saveds ASM tdo2DFileFormatNamesGet() {
  498.     if(c2dFFNames[0]!=NULL) return(c2dFFNames);
  499.     return(NULL);
  500. }
  501.  
  502. /****** tdo.library/tdo2DFileFormatIDGet ******************************************
  503. * 
  504. *   NAME    
  505. *     tdo2DFileFormatIDGet -- Get the ID of a specific 2D file format.
  506. * 
  507. *   SYNOPSIS
  508. *    id = tdo2DFileFormatIDGet( ffname )
  509. *                               D1
  510. *
  511. *    ULONG tdo2DFileFormatIDGet
  512. *         ( STRPTR );
  513. *
  514. *   FUNCTION
  515. *    You will get the ID of the 2D file format of which you passed its name.
  516. * 
  517. *   INPUTS
  518. *    ffname - Name of the format you search the ID for.
  519. *    
  520. *   RESULT
  521. *     id - The ID of the 2D file format or 0 if not found/supported.
  522. *
  523. *   EXAMPLE
  524. *    id = tdo2DFileFormatIDGet("PostScript");
  525. *
  526. *   NOTES
  527. *    Even if the values of the IDs wont change in future versions, it is
  528. *    recomended to show the list of all names to the user and let him choose
  529. *    the format. With the help of this function you will get the correct
  530. *    ID which is needed for further function calls.
  531. *
  532. *   BUGS
  533. * 
  534. *   SEE ALSO
  535. *     tdo2DFileFormatNamesGet(),tdo2DFileFormatExtensionGet()
  536. *    tdo2DFileFormatNumberOfGet()
  537. * 
  538. ******************************************************************************
  539. *
  540. */
  541. ULONG __saveds ASM tdo2DFileFormatIDGet(register __d1 STRPTR ffname) {
  542.     ULONG i;
  543.     STRPTR mffname=NULL;
  544.  
  545.     // make a copy of ffname, d1 is a scratch register
  546.     mffname=ffname;
  547.  
  548.     i=0;
  549.     while(strcmp(c2dFFNames[i],mffname) && c2dFFNames[i]!=NULL) {i++};
  550.     
  551.     // check if we got it or not
  552.     if(!strcmp(c2dFFNames[i],mffname)) return(c2dFFIDs[i]);
  553.     else return(0);
  554. }
  555.  
  556. /****** tdo.library/tdo2DFileFormatExtensionGet ******************************************
  557. * 
  558. *   NAME    
  559. *     tdo2DFileFormatExtensionGet -- Get the file extension of a specific 2D file format.
  560. * 
  561. *   SYNOPSIS
  562. *    ext = tdo2DFileFormatExtensionGet( ffid )
  563. *                                       D1
  564. *
  565. *    STRPTR tdo2DFileFormatExtensionGet
  566. *         ( ULONG );
  567. *
  568. *   FUNCTION
  569. *    You will get a pointer to the extension of the specified 2D file format.
  570. *    This strings are READ_ONLY and only valid as long as the library is opened.
  571. * 
  572. *   INPUTS
  573. *    ffid - ID of the format you search the extension for.
  574. *    
  575. *   RESULT
  576. *     ext - Pointer to the file extension string or NULL if the format is unknown.
  577. *
  578. *   EXAMPLE
  579. *    ext = tdo2DFileFormatExtensionGet(id);
  580. *
  581. *   NOTES
  582. *    This extensions are proposals of the format creators, but you are free
  583. *    to use them.
  584. *
  585. *   BUGS
  586. * 
  587. *   SEE ALSO
  588. *     tdo2DFileFormatNamesGet(),tdo2DFileFormatIDGet()
  589. *    tdo2DFileFormatNumberOfGet()
  590. * 
  591. ******************************************************************************
  592. *
  593. */
  594. STRPTR __saveds ASM tdo2DFileFormatExtensionGet(register __d1 ULONG ffid) {
  595.     ULONG i,mffid;
  596.  
  597.     // make a copy of ffid, d1 is a scratch register
  598.     mffid=ffid;
  599.     
  600.     i=0;
  601.     while(c2dFFIDs[i]!=mffid && c2dFFIDs[i]!=0) {i++};
  602.     
  603.     // check if we got it or not
  604.     if(c2dFFIDs[i]==mffid) return(c2dFFExtensions[i]);
  605.     else return(NULL);
  606. }
  607.  
  608. /****** tdo.library/tdo2DFileFormatNumberOfGet ******************************************
  609. * 
  610. *   NAME    
  611. *     tdo2DFileFormatNumberOfGet -- Get the number of supported 2D file formats.
  612. * 
  613. *   SYNOPSIS
  614. *    number = tdo2DFileFormatNumberOfGet( )
  615. *
  616. *    ULONG tdo2DFileFormatNumberOfGet
  617. *         ( );
  618. *
  619. *   FUNCTION
  620. *    You will get the number of supported 2D file formats of this library version.
  621. * 
  622. *   INPUTS
  623. *    
  624. *   RESULT
  625. *     number - Number of supported file formats or 0 if none.
  626. *
  627. *   EXAMPLE
  628. *    number = tdo2DFileFormatNumberOfGet();
  629. *
  630. *   NOTES
  631. *
  632. *   BUGS
  633. * 
  634. *   SEE ALSO
  635. *     tdo2DFileFormatNamesGet(),tdo2DFileFormatIDGet()
  636. *    tdo2DFileFormatNumberExtensionGet()
  637. * 
  638. ******************************************************************************
  639. *
  640. */
  641. ULONG __saveds ASM tdo2DFileFormatNumberOfGet() {
  642.     ULONG  i;
  643.     STRPTR *sIndex=NULL;
  644.  
  645.     i=0;
  646.     sIndex=c2dFFNames;
  647.     while (sIndex[i]!=NULL) i++;
  648.     
  649.     return(i);
  650. }
  651.  
  652. /****** tdo.library/tdoMeshSave2D ******************************************
  653. * 
  654. *   NAME    
  655. *     tdoMeshSave2D -- Saves the mesh as 2D file.
  656. *
  657. *   SYNOPSIS
  658. *    error = tdoMeshSave2D( meshhandle,id,filename,parameters )
  659. *                           D1         D2 D3        A0
  660. *
  661. *    ULONG tdoMeshSave2D
  662. *         ( ULONG,ULONG,STRPTR,T2DParams );
  663. *
  664. *   FUNCTION
  665. *    The mesh, this means vertices, polygons, materials, camera and light will
  666. *    be used to generate and save a 2D file from a specific view point and
  667. *    drawing mode in a given size.
  668. * 
  669. *   INPUTS
  670. *     meshhandle  - A valid handle of a mesh.
  671. *    id          - A valid 2D file format id, to specify the output format.
  672. *    filename    - Name and path of the file.
  673. *    parameters  - A 2D parameter sructure containing additional information.
  674. *    
  675. *   RESULT
  676. *    error - RCNOERROR         if all went well.
  677. *            RCNOMESH          if the handle is not valid.
  678. *            RCUNKNOWNFTYPE    if the id is not known.
  679. *            RCUNKNOWNDMODE    if the view mode in not known.
  680. *            RCNOPOLYGON       if there are no polygons to save.
  681. *            RCCHGBUF          if an error occured to allocate the save buffer.
  682. *            RCWRITEDATA       if an error occured while writing data, no more space...
  683. *            RCVERTEXOVERFLOW  if the format does not support as much vertices.
  684. *            RCNOWIDTH         if the width is 0.
  685. *            RCNOHEIGHT        if the height is 0.
  686. *            IoErr()           if possible to catch it, you will get its codes.
  687. *
  688. *   EXAMPLE
  689. *    error = tdoMeshSave2D(meshhandle,id,"ram:test",myparams);
  690. *
  691. *   NOTES
  692. *    No file existence tests are made here! Existent files will be overwritten.
  693. *
  694. *   BUGS
  695. * 
  696. *   SEE ALSO
  697. *     tdo2DFileFormatIDGet(),tdoDrawModeGet(),tdoMeshSave3D()
  698. * 
  699. ******************************************************************************
  700. *
  701. */
  702. ULONG __saveds ASM tdoMeshSave2D(register __d1 ULONG meshhandle,
  703.                                     register __d2 ULONG id,
  704.                                     register __d3 STRPTR filename,
  705.                                     register __a0 T2DParams *parameters) {
  706.     TTDOMesh        *mesh;
  707.     BPTR            filehandle=NULL;
  708.     ULONG            retcode=RCNOERROR;
  709.     UBYTE            i;
  710.     T2DParams        *mparams=NULL;
  711.     
  712.     // make a copy of the parameters, a0 is a scratch register
  713.     mparams=parameters;
  714.  
  715.     mesh = (TTDOMesh *) meshhandle;
  716.     if(mesh==NULL) return(RCNOMESH);    
  717.  
  718.       /*
  719.       ** If there are no polygons, so leave
  720.       */
  721.     if(mesh->polygons.firstNode==NULL) return(RCNOPOLYGON);
  722.     
  723.     /*
  724.     ** Check if the filetype is valid
  725.     */
  726.     i=0;
  727.     while(c2dFFIDs[i]!=id && c2dFFIDs[i]!=0) {i++};
  728.     if(c2dFFIDs[i]!=id || id==0) return(RCUNKNOWNFTYPE);
  729.     
  730.     /*
  731.     ** Check if the viewtype is valid
  732.     */
  733.     if(!(mparams->viewtype==TVWTOP ||
  734.         mparams->viewtype==TVWBOTTOM ||
  735.         mparams->viewtype==TVWLEFT ||
  736.         mparams->viewtype==TVWRIGHT ||
  737.         mparams->viewtype==TVWFRONT ||
  738.         mparams->viewtype==TVWREAR ||
  739.         mparams->viewtype==TVWPERSP ||
  740.         mparams->viewtype==TVW4SIDES)) return(RCUNKNOWNVTYPE);
  741.  
  742.     /*
  743.     ** Check if the drawmode is valid
  744.     */
  745.     i=0;
  746.     while(cDMIDs[i]!=mparams->drawmode && cDMIDs[i]!=0) {i++};
  747.     if(cDMIDs[i]!=mparams->drawmode || mparams->drawmode==0) return(RCUNKNOWNDMODE);
  748.     
  749.     /*
  750.     ** Check if the width is set
  751.     */
  752.     if (mparams->width==0) {
  753.         return(RCNOWIDTH);
  754.     }
  755.  
  756.     /*
  757.     ** Check if the height is set
  758.     */
  759.     if (mparams->height==0) {
  760.         return(RCNOHEIGHT);
  761.     }
  762.  
  763.     /*
  764.     ** If no camera and light position was given, set it to default now
  765.     */
  766.     if (!(mesh->camera.position.x &&
  767.          mesh->camera.position.y &&
  768.          mesh->camera.position.z &&
  769.          mesh->camera.lookat.x &&
  770.          mesh->camera.lookat.y &&
  771.          mesh->camera.lookat.z &&
  772.          mesh->light.position.x &&
  773.          mesh->light.position.y &&
  774.          mesh->light.position.z)) setCameraLight(mesh);
  775.  
  776.     /*
  777.     ** Open the file 
  778.     */
  779.     /* Open the file for text output */
  780.     if((filehandle=Open(filename,MODE_NEWFILE))==NULL) return(IoErr());
  781.  
  782.     /* Change the buffer size of the filehandle to 10k */
  783.     if (SetVBuf(filehandle,NULL,BUF_FULL,10000)!=DOSFALSE) {
  784.         Close(filehandle);
  785.         return(RCCHGBUF);
  786.     }
  787.  
  788.     /*
  789.     ** Write the mesh
  790.     */
  791.     switch(id) {
  792.         case T2DFEPS :
  793. //            retcode = write2EPS(filehandle,mesh,mparams->viewtype,mparams->drawmode,mparams->width,mparams->height);
  794.             break;        
  795.     }
  796.     
  797.     /*
  798.     ** Close the file
  799.     */
  800.     Close(filehandle);
  801.     
  802.     return(retcode);
  803. }
  804.  
  805. /****** tdo.library/tdoDrawModeNamesGet ******************************************
  806. * 
  807. *   NAME 
  808. *        tdoDrawModeNamesGet -- Get a name list of all supported drawing modes.
  809. * 
  810. *   SYNOPSIS
  811. *        list = tdoDrawModeNamesGet(  )
  812. *
  813. *        STRPTR * tdoDrawModeNamesGet
  814. *             (  );
  815. *
  816. *   FUNCTION
  817. *        You will get a pointer to the namelist of all supported drawing modes.
  818. *        This strings are READ_ONLY and only valid as long as the library is opened.
  819. *
  820. *        The resulting pointer can directly be used to fill up cycle or list gadgets
  821. *        for example.
  822. *
  823. *   INPUTS
  824. *        
  825. *   RESULT
  826. *        list - A NULL terminated array of string pointers. Or NULL if no
  827. *               modes are supported.
  828. *
  829. *   EXAMPLE
  830. *        list = tdoDrawModeNamesGet();
  831. *
  832. *   NOTES
  833. *
  834. *   BUGS
  835. * 
  836. *   SEE ALSO
  837. *        tdoDrawModeIDGet(),tdoDrawModeNumberOfGet()
  838. * 
  839. ******************************************************************************
  840. *
  841. */
  842. STRPTR * __saveds ASM tdoDrawModeNamesGet() {
  843.     if(cDMNames[0]!=NULL) return(cDMNames);
  844.     return(NULL);
  845. }
  846.  
  847. /****** tdo.library/tdoDrawModeIDGet ******************************************
  848. * 
  849. *   NAME 
  850. *        tdoDrawModeIDGet -- Get the ID of a specific drawing mode.
  851. * 
  852. *   SYNOPSIS
  853. *        id = tdoDrawModeIDGet( dmname )
  854. *                               D1
  855. *
  856. *        ULONG tdoDrawModeIDGet
  857. *             ( STRPTR );
  858. *
  859. *   FUNCTION
  860. *        You will get the ID of the drawing mode of which you passed its name.
  861. * 
  862. *   INPUTS
  863. *        dm - Name of the drawing mode you search the ID for.
  864. *        
  865. *   RESULT
  866. *        id - The ID of the drawing mode or 0 if not found/supported.
  867. *
  868. *   EXAMPLE
  869. *        id = tdoDrawModeIDGet("Points");
  870. *
  871. *   NOTES
  872. *        Even if the values of the IDs wont change in future versions, it is
  873. *        recomended to show the list of all names to the user and let him choose
  874. *        the format. With the help of this function you will get the correct
  875. *        ID which is needed for further function calls.
  876. *
  877. *   BUGS
  878. * 
  879. *   SEE ALSO
  880. *        tdoDrawModeNamesGet(),tdoDrawModeNumberOfGet()
  881. * 
  882. ******************************************************************************
  883. *
  884. */
  885. ULONG __saveds ASM tdoDrawModeIDGet(register __d1 STRPTR ffname) {
  886.     ULONG i;
  887.     STRPTR mffname=NULL;
  888.  
  889.     // make a copy of ffname, d1 is a scratch register
  890.     mffname=ffname;
  891.  
  892.     i=0;
  893.     while(strcmp(cDMNames[i],mffname) && cDMNames[i]!=NULL) {i++};
  894.     
  895.     // check if we got it or not
  896.     if(!strcmp(cDMNames[i],mffname)) return(cDMIDs[i]);
  897.     else return(0);
  898. }
  899.  
  900. /****** tdo.library/tdoDrawModeNumberOfGet ******************************************
  901. * 
  902. *   NAME 
  903. *        tdoDrawModeNumberOfGet -- Get the number of supported drawing modes.
  904. * 
  905. *   SYNOPSIS
  906. *        number = tdoDrawModeNumberOfGet( )
  907. *
  908. *        ULONG tdoDrawModeNumberOfGet
  909. *             ( );
  910. *
  911. *   FUNCTION
  912. *        You will get the number of supported drawing modes of this library version.
  913. * 
  914. *   INPUTS
  915. *        
  916. *   RESULT
  917. *        number - Number of supported drawing modes or 0 if none.
  918. *
  919. *   EXAMPLE
  920. *        number = tdoDrawModeNumberOfGet();
  921. *
  922. *   NOTES
  923. *
  924. *   BUGS
  925. * 
  926. *   SEE ALSO
  927. *        tdoDrawModeNamesGet(),tdoDrawModeIDGet()
  928. * 
  929. ******************************************************************************
  930. *
  931. */
  932. ULONG __saveds ASM tdoDrawModeNumberOfGet() {
  933.     ULONG  i;
  934.     STRPTR *sIndex=NULL;
  935.  
  936.     i=0;
  937.     sIndex=cDMNames;
  938.     while (sIndex[i]!=NULL) i++;
  939.     
  940.     return(i);
  941. }
  942.  
  943. /*
  944. TODO
  945.  
  946. Lightwave,Imagine,Videoscape  groessen/anzahl checks fertigmachen !!
  947.  
  948. Material mehr parameter, brechungsindex, reflektion, ...
  949.  
  950. */
  951.  
  952. /************************* End of file ******************************/
  953.  
  954.